package com.ltmonitor.web.controller;

import java.lang.reflect.Proxy;
import java.text.DateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.springframework.remoting.rmi.RmiProxyFactoryBean;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.ltmonitor.service.ITransferService;
import com.ltmonitor.service.ITransferServiceOld;
import com.ltmonitor.util.DateUtil;
import com.ltmonitor.vo.GnssData;
import com.ltmonitor.web.util.DateFormatter;
import com.ltmonitor.web.util.JsonMessage;
import com.ltmonitor.web.util.MyInvocationHandler;
import com.ltmonitor.web.util.SpringApplicationContextHolder;
import com.sun.tools.javac.tree.JCTree.LetExpr;

import javassist.expr.NewArray;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

/**
 * @author shinion
 * @date 2019-07-27
 * 插入数据并调用809转发服务转发至政府平台
 *
 */
@Controller
@RequestMapping("/insertAndTrans")
public class InsertAndTransController extends PaginateAction {
	private Logger mylog = Logger.getLogger("debug");
	
	//旧809转发服务 spring版本2.5
	private ITransferServiceOld transServiceOld;
	//新809转发服务 spring版本3以上
	private ITransferService transService;
	//新809转发服务，三宝平台
	private ITransferService transService_sanbao;
	
	private String  trans_url_old = "";//定义旧809rmi地址
	private String trans_url_new = "";//定义新809rmi地址
	private String transType= "";//定义转发类型，“old”or“new”
	
	/**
	 * 请求补数据页面
	 * @param model
	 * @return
	 */
	@RequestMapping("/viewInsertGpsDataPage.action")
	public String viewInsertGpsDataPage(
			@RequestParam(value="disId" , defaultValue="0" )int disId,
			@RequestParam(value="type" , defaultValue="0" )int type,
			Model model) {
		model.addAttribute("message", "hello");
		model.addAttribute("disId", disId);
		model.addAttribute("type",type);
//		mylog.info("请求gps数据补轨迹页面！");
//		mylog.error("测试错误日志数据！");
		return "insertAndTrans/insertGpsDataPage";
	}
	
	
	
	/**
	 * 插入gps补轨迹数据
	 * @param jsonStr
	 * @return
	 */
	@RequestMapping("/insertGpsDatas.action")
	@ResponseBody
	public JsonMessage insertGpsDatas(@RequestBody String jsonStr) {
		JsonMessage result = null;
		String msg = "";
		try {
			Map map = JSONObject.fromObject(jsonStr);
			
			//获取转发
			boolean transFlg  = false;
			if(map.get("transFlg") != null) {
				transFlg = true;
				mylog.info("本次补轨迹允许809server转发数据！");
			}else {
				mylog.info("************本次补轨迹不允许809server转发数据！");
			}
			//获取插入标记
			boolean insertFlg = false;
			if(map.get("insertFlg") != null) {
				insertFlg = true;
				mylog.info("本次补轨迹允许插入到数据库!");
			}else {
				mylog.info("************本次补轨迹不允许插入到数据库！");
			}
			
			List list = null;
			int nums = 0;
			if(map.get("gpsList") != null) {
				list = JSONArray.fromObject(map.get("gpsList"));
				if(list != null && list.size() > 0) {
					//不操作
				}else {
					msg += "解析gps数据失败！";
				}
			}else {
				msg += "获取列表数据失败！";
			}

			//允许转发，解析转发数据
			if(transFlg) {
				msg += getTransInfo(map);				
			}
			
			if(msg.equals("")) {
				if(list.size() > 0) {
					nums = list.size();
					map.remove("gpsList");
					String queryId = "insertAndTrans.insertOneGpsData";
					for(int i=0 ; i< list.size() ; i++) {
						Map insertMap = (Map) list.get(i);
						insertMap.put("velocity", insertMap.get("speed"));
						insertMap.putAll(map);
//						mylog.info(" 数据：" + i + list.get(i).toString());
//						System.out.println(" 数据：" + i + list.get(i).toString());
						if(msg.equals("")) {
							if(insertFlg) {
								queryService.insert(queryId, insertMap);								
							}
							//转发数据
							if(transFlg) {
								msg += transGpsData(insertMap);								
							}
						}else {
							//出现错误信息，跳出，不继续插入数据
							break;
						}
					}					
				}
			}
			
			// 消息写入日志
			if(!msg.equals("")) {
				map.remove("gpsList");
				mylog.error("本次补轨迹失败：失败原因：" + msg + "基本数据为：" + map.toString());
			}else {
				mylog.info("本次补轨迹成功，共处理" + nums + "条轨迹数据,基本数据为：" + map.toString());
			}

			result = BasicSlctAction.getReturnResult(msg, "插入GPS补轨迹数据成功!", nums);
		} catch (Exception e) {
			// TODO: handle exception
			msg += "insertAndTrans---->插入gps补轨迹数据失败：" + e.getMessage();
			log.error(msg);
			mylog.error(msg);
			result = new JsonMessage(false, msg);
		}
		
		return result;
	}
	
	
	//从map中获取转发相关信息
	private String getTransInfo(Map map) {
		String msg = "";
		try {
			if(map.get("transFlg") != null) {
				if(map.get("transType")!= null || map.get("transUrl") != null) {
					transType = map.get("transType").toString();
					
					if(transType.equals("old")) {
						trans_url_old = map.get("transUrl").toString();
					}else if(transType.equals("new")) {
						trans_url_new = map.get("transUrl").toString();
					}else {
						msg += "解析转发类型失败， 转发类型数据为：" + transType;
						transType = "";
					}
					System.out.println("trans_url_new:" + trans_url_new);
					
				}else {
					msg += "获取转发数据失败！";
				}
			}			
		} catch (Exception e) {
			// TODO: handle exception
			msg += "解析转发信息失败：" + e.getMessage();
			mylog.error(msg);
		}
		
		return msg;
	}
	
	//转发数据，成功返回空字符串，失败返回错误信息
	//trans_type:转发类型，“old”表示旧809转发，“new”表示新809转发
	private String transGpsData(Map map) {
		String msg = "";
		try {
			if(!transType.equals("")) {
				double longitude = Double.valueOf(map.get("longitude").toString()) * 1000000;
				double latitude = Double.valueOf(map.get("latitude").toString()) * 1000000;
				
				if(transType.equals("new")) {
					//新809转发
					GnssData gpsData = new GnssData();
//					org.apache.commons.beanutils.BeanUtils.populate(gpsData, map);
					//车牌号，车牌颜色
					gpsData.setPlateNo(map.get("plateNo").toString());
					gpsData.setPlateColor(Integer.valueOf(map.get("plateColor").toString()));
					// 经纬度
					gpsData.setLongitude((int) longitude);
					gpsData.setLatitude((int) latitude);
					// 车机时间
					gpsData.setPosTime(DateUtil.stringToDateTime(map.get("sendTime").toString()));
					// 速度
					gpsData.setGpsSpeed((int) (double) Double.valueOf(map.get("speed").toString()));
					gpsData.setRecSpeed((int) (double) Double.valueOf(map.get("recSpeed").toString()));
					// 累计里程
					gpsData.setTotalMileage((int) (double) Double.valueOf(map.get("mileage").toString()));
					// 方向
					gpsData.setDirection(Integer.valueOf(map.get("direction").toString()));
					// 海拔
					gpsData.setAltitude((int) (double) Double.valueOf(map.get("altitude").toString()));
					// 报警数据
					gpsData.setAlarmState(Integer.valueOf(map.get("alarmState").toString()));
					// 车辆状态数据
					gpsData.setVehicleState(Integer.valueOf(map.get("status").toString()));
					// 是否加偏
					gpsData.setPosEncrypt(0);
					
					//转发
					msg += transDataNew(gpsData);
				}else if(transType.equals("old")) {
					//旧809转发
					com.ltmonitor.entity.GnssData gpsData_old = new com.ltmonitor.entity.GnssData();
					
					//车牌号，车牌颜色
					gpsData_old.setPlateNo(map.get("plateNo").toString());
					gpsData_old.setPlateColor(Integer.valueOf(map.get("plateColor").toString()));
					// 经纬度
					gpsData_old.setLongitude((int) longitude);
					gpsData_old.setLatitude((int) latitude);
					// 车机时间
					gpsData_old.setPosTime(DateUtil.stringToDateTime(map.get("sendTime").toString()));
					// 速度
					gpsData_old.setGpsSpeed((int) (double) Double.valueOf(map.get("speed").toString()));
					gpsData_old.setRecSpeed((int) (double) Double.valueOf(map.get("recSpeed").toString()));
					// 累计里程
					gpsData_old.setTotalMileage((int) (double) Double.valueOf(map.get("mileage").toString()));
					// 方向
					gpsData_old.setDirection(Integer.valueOf(map.get("direction").toString()));
					// 海拔
					gpsData_old.setAltitude((int) (double) Double.valueOf(map.get("altitude").toString()));
					// 报警数据
					gpsData_old.setAlarmState(Integer.valueOf(map.get("alarmState").toString()));
					// 车辆状态数据
					gpsData_old.setVehicleState(Integer.valueOf(map.get("status").toString()));
					// 是否加偏
					gpsData_old.setPosEncrypt(0);
					
					//转发
					msg += transDataOld(gpsData_old);
				}
				
			} else {
				msg += "转发服务对象为空，无法转发";
			}	
		} catch (Exception e) {
			// TODO: handle exception
			msg +="解析数据错误，无法转发 :" + e.getMessage();
			mylog.error(msg);
			e.printStackTrace();
		}
		return msg;
	}
	
	//调用新809进行转发服务
	private String transDataNew(GnssData data) {
		String msg = "";
		try {
			if(transService == null) {
				transService = SpringApplicationContextHolder.getBean("transferService"); 
//				if(!trans_url_new.equals("")) {
//					
//				}else {
//					msg += "rmi服务地址为空，无法调用转发服务！";
//				}
			}			
			
			//转发
			if(transService != null) {
				transService.UpExgMsgRealLocation(data);
//				mylog.info("新809转发一条GPS定位数据  , data:" + data.toString());
//				System.out.println(transService.toString());
			}
		} catch (Exception e) {
			// TODO: handle exception
			msg += "调用新809转发服务失败：" + e.getMessage();
			mylog.error(msg);
		}
		return msg;
	}
	
	//调用旧809进行转发服务
	//旧809转发服务
	private String transDataOld(com.ltmonitor.entity.GnssData data) {
		String msg = "";
		try {
			if(transServiceOld == null) {
				if(!trans_url_old.equals("")) {
					RmiProxyFactoryBean factory = new RmiProxyFactoryBean();
					factory.setServiceInterface(ITransferServiceOld.class);
					factory.setServiceUrl(trans_url_old);
					
					factory.setLookupStubOnStartup(false);
					factory.setRefreshStubOnConnectFailure(true);
					factory.afterPropertiesSet();
					
					Object object = factory.getObject();
					MyInvocationHandler handler = new MyInvocationHandler(object);
					ClassLoader loader = InsertAndTransController.class.getClassLoader();
					Class<?>[] interfaces = object.getClass().getInterfaces();
					
					transServiceOld = (ITransferServiceOld) Proxy.newProxyInstance(loader, interfaces, handler);
				}else {
					msg += "rmi服务地址为空，无法调用旧809转发服务！";
				}
			}			
			
			//转发
			if(transServiceOld != null) {
				transServiceOld.UpExgMsgRealLocation(data);
//				mylog.info("旧809转发一条GPS定位数据！");
			}
		} catch (Exception e) {
			// TODO: handle exception
			msg += "调用旧809转发服务失败：" + e.getMessage();
			mylog.error(msg);
		}
		return msg;
	}
	
	
	/**
	 * 转发数据至三宝平台
	 * @param data
	 * @return
	 */
	private String transDataSanbao(GnssData data){
		String msg = "";
		try {
			if(transService_sanbao == null) {
				transService_sanbao = SpringApplicationContextHolder.getBean("transferService_sanbao"); 
			}			
			
			//转发
			if(transService_sanbao != null) {
				transService_sanbao.UpExgMsgRealLocation(data);
			}
		} catch (Exception e) {
			// TODO: handle exception
			msg += "转发至三宝平台失败：" + e.getMessage();
			mylog.error(msg);
		}
		return msg;
	}
	
	
	
	/**
	 * 转发临时数据
	 * @param jsonStr
	 * @return
	 */
	@RequestMapping("/transMyData.action")
	@ResponseBody
	public JsonMessage transMyData(@RequestBody String jsonStr) {
		mylog.error(jsonStr);
		JsonMessage result = null;
		String msg = "";
		try {
			Map map = JSONObject.fromObject(jsonStr);
			String queryId = "insertAndTrans.selectAllVeh";
			//获取车辆数据
			List vehList = queryService.query(queryId, null);
			System.out.println(vehList.toString());
			mylog.error("需要转发的车辆数量为："+vehList.size() + " 辆!");
			//开始遍历车辆获取GPS数据
			for(int i=0 ; i<vehList.size() ; i++) {
				Map temp = (Map) vehList.get(i);
				temp.putAll(map);
				transOneVehTempGpsData(temp);
			}
			
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			result = new JsonMessage(false, "转发数据失败：" +e.getMessage());
		}
		
		result = new JsonMessage(true, null);
		
		return result;
	}
	
	
	//单个车辆GPS数据查询语句
	private String queryIdOneVehGps = "insertAndTrans.selectGpsDataByOneVeh";
	
	/**
	 * 转发单个车辆指定时间内的gps数据
	 * @param jsonStr
	 * @return
	 */
	@RequestMapping("/transOneVehGpsData.action")
	@ResponseBody
	public JsonMessage transOneVehGpsData(@RequestBody String jsonStr){
		JsonMessage result = null;
		String msg = "";
		try {
			Map resultMap = new HashMap();//结果缓存
			Map vehMap = JSONObject.fromObject(jsonStr);
			List gpsDatas = queryService.query(queryIdOneVehGps, vehMap);
			if(gpsDatas != null && gpsDatas.size() > 0){
				resultMap.put("gpsNum", gpsDatas.size());
				mylog.info("开始转发一个车辆的gps定位数据，参数为为：" + jsonStr);
				mylog.error("当前车辆gps数据数量为：" + gpsDatas.size());
				for(int i=0 ; i<gpsDatas.size() ; i++) {
					Map map = (Map) gpsDatas.get(i);
					GnssData gpsData = getNewGnssData(map, vehMap);
					if(gpsData != null && msg.equals("")){
						if(vehMap.containsKey("name")){
							if(vehMap.get("name").toString().equals("base")){
								//转发联网联控平台
								msg += transDataNew(gpsData);		
							}else {
								msg +=transDataSanbao(gpsData);
							}
						}else {
							msg += "当前参数中没有包含转发平台类型,参数数据为："  + jsonStr;
							mylog.error(msg);
						}
					}
				}
			}else {
				resultMap.put("gpsNum", 0);
				mylog.info("当前车辆当前时间无gps数据，无需转发,参数为：" + jsonStr);
			}
			
			//更新转发状态
			if(msg.equals("")){
				//更新数据
				msg = updateTransVehStatus(vehMap.get("plateNo").toString(), 1, "转发成功");
				if(!msg.equals("")){
					msg = "转发成功 ，" + msg;
				}
			}else {
				//更新状态
				msg += updateTransVehStatus(vehMap.get("plateNo").toString(), 2, "转发失败");
			}
			
			
			resultMap.put("transDate", new Date());//保存时间
			
			if(msg.equals("")){
				mylog.info("转发成功！");
				//更新数据
				result = new JsonMessage(true,resultMap);
			}else {
				mylog.error("转发失败：" + msg);
				result = new JsonMessage(false, msg);
				result.setData(resultMap);
			}
		} catch (Exception e) {
			// TODO: handle exception
			msg += "发送单个车辆的gps数据失败：" + e.getMessage();
			mylog.error(msg);
			result = new JsonMessage(false, msg);
		}
		return result;
	}
	
	//更新转发状态数据
	private String queryIdUpdateTransStatus = "insertAndTrans.updateTransVehStatusData";
	
	//更新转发车辆状态
	private String updateTransVehStatus(String plateNo,int status,String remark){
		String msg = "";
		try {
			Map map = new HashMap ();
			map.put("plateNo", plateNo);
			map.put("status", status);
			map.put("remark", remark);
			map.put("transDate", new Date());
			queryService.update(queryIdUpdateTransStatus, map);
		} catch (Exception e) {
			// TODO: handle exception
			msg += "更新车辆转发结果失败 ：" + e.getMessage();
		}
		return msg;
	}
	
	
	//转发单个车辆的信息
	private void transOneVehTempGpsData(Map vehMap) {
		try {
			String str = "序号：" + vehMap.get("id") + " , 车牌号：" + vehMap.get("plateNo") ;
			mylog.error("-------------------------------------------------------");
			mylog.error(str + "开始转发GPS数据............");
			
			String queryId = "insertAndTrans.selectGpsDataByOneVeh";
			List gpsDatas = queryService.query(queryId, vehMap);
			if(gpsDatas != null && gpsDatas.size() > 0) {
				mylog.error("当前车辆gps数据数量为：" + gpsDatas.size());
				for(int i=0 ; i<gpsDatas.size() ; i++) {
					//新809转发
					Map map = (Map) gpsDatas.get(i);
//					GnssData gpsData = new GnssData();
//					double longitude = Double.valueOf(map.get("longitude").toString()) * 1000000;
//					double latitude = Double.valueOf(map.get("latitude").toString()) * 1000000;
////					org.apache.commons.beanutils.BeanUtils.populate(gpsData, map);
//					//车牌号，车牌颜色
//					gpsData.setPlateNo(map.get("plateNo").toString());
//					gpsData.setPlateColor(Integer.valueOf(vehMap.get("plateColor").toString()));
//					// 经纬度
//					gpsData.setLongitude((int) longitude);
//					gpsData.setLatitude((int) latitude);
//					// 车机时间
//					gpsData.setPosTime(DateUtil.stringToDateTime(map.get("sendTime").toString()));
//					// 速度
//					gpsData.setGpsSpeed((int) (double) Double.valueOf(map.get("velocity").toString()));
//					gpsData.setRecSpeed((int) (double) Double.valueOf(map.get("velocity").toString()));
//					// 累计里程
//					gpsData.setTotalMileage((int) (double) Double.valueOf(map.get("mileage").toString()));
//					// 方向
//					gpsData.setDirection(Integer.valueOf(map.get("direction").toString()));
//					// 海拔
//					gpsData.setAltitude((int) (double) Double.valueOf(map.get("altitude").toString()));
//					// 报警数据
////					gpsData.setAlarmState(Integer.valueOf(map.get("alarmState").toString()));
//					gpsData.setAlarmState(0);
//					// 车辆状态数据
//					gpsData.setVehicleState(Integer.valueOf(map.get("status").toString()));
//					// 是否加偏
//					gpsData.setPosEncrypt(0);
					GnssData gpsData = getNewGnssData(map, vehMap);
					if(gpsData != null){
						//转发
						transDataNew(gpsData);						
					}
				}
			}else {
				mylog.error("当前车辆当前时间无gps数据，无需转发");
			}
		} catch (Exception e) {
			// TODO: handle exception
			mylog.error("转发车辆数据失败：" + e.getMessage());
			e.printStackTrace();
		}
		
		
	}

	//获取新的转发数据信息
	private GnssData getNewGnssData(Map map,Map vehMap){
		GnssData gpsData = null;
		try {
			gpsData = new GnssData();
			double longitude = Double.valueOf(map.get("longitude").toString()) * 1000000;
			double latitude = Double.valueOf(map.get("latitude").toString()) * 1000000;
//			org.apache.commons.beanutils.BeanUtils.populate(gpsData, map);
			//车牌号，车牌颜色
			gpsData.setPlateNo(map.get("plateNo").toString());
			gpsData.setPlateColor(Integer.valueOf(vehMap.get("plateColor").toString()));
			// 经纬度
			gpsData.setLongitude((int) longitude);
			gpsData.setLatitude((int) latitude);
			// 车机时间
			gpsData.setPosTime(DateUtil.stringToDateTime(map.get("sendTime").toString()));
			// 速度
			gpsData.setGpsSpeed((int) (double) Double.valueOf(map.get("velocity").toString()));
			gpsData.setRecSpeed((int) (double) Double.valueOf(map.get("velocity").toString()));
			// 累计里程
			gpsData.setTotalMileage((int) (double) Double.valueOf(map.get("mileage").toString()));
			// 方向
			gpsData.setDirection(Integer.valueOf(map.get("direction").toString()));
			// 海拔
			gpsData.setAltitude((int) (double) Double.valueOf(map.get("altitude").toString()));
			// 报警数据
//			gpsData.setAlarmState(Integer.valueOf(map.get("alarmState").toString()));
			gpsData.setAlarmState(0);
			// 车辆状态数据
			gpsData.setVehicleState(Integer.valueOf(map.get("status").toString()));
			// 是否加偏
			gpsData.setPosEncrypt(0);	
		} catch (Exception e) {
			// TODO: handle exception
			gpsData = null;
			mylog.error("解析单个GPS数据出错，数据为："+map.toString()+"，原因：" + e.getMessage());
		}
		return gpsData;
	}
	

	/**
	 * 更新时间线数据
	 * @param jsonStr
	 * @return
	 */
	@RequestMapping("/updateGpsTimeLine.action")
	@ResponseBody
	public JsonMessage updateGpsTimeLine(@RequestBody String jsonStr){
		JsonMessage result = null;
		String msg = "";
		try {
			Map map = JSONObject.fromObject(jsonStr);
			if(map.containsKey("startDate") && map.containsKey("endDate") && map.containsKey("plateNo")&&map.containsKey("timeOffset")){
				//初始化起止时间
				int timeOffset = Integer.valueOf(map.get("timeOffset").toString());
				long startLong = DateUtil.getDateTimeLong(map.get("startDate").toString());
				long endLong = DateUtil.getDateTimeLong(map.get("endDate").toString());
				map.put("startLong", startLong);
				map.put("endLong", endLong);
				map.put("newStartDate", DateUtil.datetimeToString(new Date(startLong - timeOffset * 1000 )));
				map.put("newEndDate", DateUtil.datetimeToString(new Date(endLong + timeOffset * 1000 )));
				
				String queryId = "insertAndTrans.getOneVehGpsTimeLineDatas";
				List listTime = queryService.query(queryId, map);
				if(listTime != null){
					if(listTime.size() > 0){
						//时间线列表数据不为空，需要校验数据
						msg += checkOneVehGpsTimeLineDatas(listTime, map);
					}else {
						//时间线为空，合法，开始插入时间线数据
						msg += insertOneGpsTimeLineData(map);
					}
				}else {
					msg += "查询时间线数据失败，无法进行处理更新！";
				}				
			}else {
				msg += "更新时间所需参数缺失，无法进行更新,当前参数：" + jsonStr;
			}
			
			//格式化返回结果
			if(msg.equals("")){
				msg = "更新时间线成功！";
				result = new JsonMessage(true,map);
				result.setMessage(msg);
			}else {
				result = new JsonMessage(false, msg);
				mylog.error(msg);
			}
			
		} catch (Exception e) {
			// TODO: handle exception
			msg += "更新时间线数据失败：" + e.getMessage();
			result = new JsonMessage(false, msg);
		}
		
		return result;
	}
	
	
	/**
	 * 校验一个列表，并且根据情况添加或者更新时间线
	 * @param list
	 * @param map
	 * @return
	 */
	private String checkOneVehGpsTimeLineDatas(List list,Map map){
		String msg = "";
		try {
			//遍历时间线,判断是否有时间重合,如果没有重合，查找最近的一个点
			long startLong = (long) map.get("startLong");
			long endLong  = (long) map.get("endLong");
			boolean timeValFlg = true;//时间差值标记，true表示，没有重合，并且计算的时间差最小值合法，false表示列表中的时间和当前时间段有重合，
			int minValueId = -1;//时间差最小值或者时间重合时所在的时间线数据库索引
			long minValue = 0;//时间差值最小值,单位为秒
			int minValPointFlg = -1;//需要插入的时间线在当前时间线哪一侧，0表示起点左侧，1表示终点右侧
			
			for(int i=0 ; i<list.size() ; i++){
				Map temp = (Map) list.get(i);
				long tempStartLong = DateUtil.getDateTimeLong(temp.get("startSendTime").toString());
				long tempEndLong = DateUtil.getDateTimeLong(temp.get("endSendTime").toString());
				if(tempStartLong >0 && tempEndLong > 0){
					if(isCoincideLine(startLong,endLong,tempStartLong,tempEndLong)){
						//当前时间线和要插入的时间线有重合,保存标记，跳出
						timeValFlg = false;
						minValueId = (int) temp.get("Id");
						msg += "更新时间线失败，存在重合的时间线，数据为：" + temp.toString() + " ， 当前要插入的时间线数据：" + map.toString();
						break;
					}else {
						//插入的时间线起点在当前时间线右侧
						if(startLong > tempEndLong){
							int tempValue = (int)((startLong - tempEndLong) /1000);
							if((i== 0 && minValueId == -1) || (tempValue <= minValue)){
								//当前没有最小值,或者当前值小于最小值
								minValueId = (int) temp.get("Id");
								minValue = tempValue;
								minValPointFlg = 1;//右侧
							}
						}
						
						//插入的时间线终点在当前时间线左侧
						if(endLong < tempStartLong){
							int tempValue = (int)((tempStartLong - endLong) /1000);
							if((i== 0 && minValueId == -1) || (tempValue <= minValue)){
								//当前没有最小值，或者当前值小于最小值
								minValueId = (int) temp.get("Id");
								minValue = tempValue;
								minValPointFlg = 0;//左侧
							}
						}
					}
				}else {
					msg += "解析时间线失败，时间线数据：" + temp.toString();
				}
			}//end for
			
			
			//判断是否计算出值
			if(timeValFlg == true && minValueId > -1){//没有重合
				if(minValue <= Integer.valueOf(map.get("timeOffset").toString())){
					//最小值小于偏移值，可以更新
					map.put("minValueId", minValueId);//保存索引
					map.put("minValPointFlg", minValPointFlg);//保存标记，左侧还是右侧
					msg += updateOneGpsTimeLineData(map);//更新
				}else {
					// 最小值大于偏移值，需要插入
					msg += insertOneGpsTimeLineData(map);//插入
				}
			}
			
		} catch (Exception e) {
			// TODO: handle exception
			msg += "校验时间线数据列表失败：" + e.getMessage();
		}
		return msg;
	}

	//判断两个线段是否重合,默认为不重合，如果重合返回true
	private boolean isCoincideLine(long startLong,long endLong,long tempStartLong,long tempEndLong){
		boolean result = false;
		
		//判断当前时间线是否在临时时间线中
		if((startLong >= tempStartLong && startLong <= tempEndLong) ||
				(endLong >= tempStartLong && endLong <= tempEndLong)){
			result =  true;
		}
		
		//判断临时时间线是否在当前时间线中
		if((tempStartLong >= startLong && tempStartLong <= endLong) ||
				(tempEndLong >= startLong && tempEndLong <= endLong)){
			result = true;
		}
		return result;
	}
	
	/**
	 * 	插入一个车辆的时间线数据
	 * @param map
	 * @return
	 */
	private String insertOneGpsTimeLineData(Map map){
		String msg = "";
		try {
			map.put("createDate", DateUtil.datetimeToString(new Date()));
			map.put("owner", "shinion_insert");
			//重置开始结束时间
			map.put("startSendTime", map.get("startDate"));
			map.put("endSendTime", map.get("endDate"));
			map.put("ensLatitude", map.get("endLatitude"));//补全终点纬度
			String queryId = "insertAndTrans.insertOneGpsTimeLineData";
			queryService.insert(queryId, map);
			int id = 0;
			if(map.containsKey("Id")){
				id = Integer.valueOf(map.get("Id").toString());
				mylog.info("插入一个新的时间线成功，更新数据为：" +map.toString());
			}
			if(id <= 0){
				msg += "插入新的时间线数据失败,需要插入的数据为：" + map.toString();
			}
		} catch (Exception e) {
			// TODO: handle exception
			msg += "插入新的时间线数据失败：" + e.getMessage() + " ----------，插入数据：" + map.toString();
		}
		return msg;
	}
	
	/**
	 * 更新一个车辆的时间线数据
	 * @param map
	 * @return
	 */
	private String updateOneGpsTimeLineData(Map map){
		String msg = "";
		try {
			if(map.containsKey("minValueId") && map.containsKey("minValPointFlg")){
				int flg = Integer.valueOf(map.get("minValPointFlg").toString());
				Map mapUpdate = new HashMap();
				mapUpdate.put("Id", map.get("minValueId"));//放入Id
				if(flg == 0){
					//要当前要插入的时间线在数据库中时间线的左侧，需要更新起点时间
					mapUpdate.put("startSendTime", map.get("startDate"));
					mapUpdate.put("startLatitude", map.get("startLatitude"));
					mapUpdate.put("startLongitude", map.get("startLongitude"));
					mapUpdate.put("startMileage", map.get("startMileage"));
					mapUpdate.put("startAcc", map.get("startAcc"));
					mapUpdate.put("startVelocity", map.get("startVelocity"));
				}else  if(flg == 1){
					mapUpdate.put("endSendTime", map.get("endDate"));
					mapUpdate.put("ensLatitude", map.get("endLatitude"));///////////////////////字段名输入手误，注意转换
					mapUpdate.put("endLongitude", map.get("endLongitude"));
					mapUpdate.put("endMileage", map.get("endMileage"));
					mapUpdate.put("endAcc", map.get("endAcc"));
					mapUpdate.put("endVelocity", map.get("endVelocity"));
				}else {
					msg += "获取更新时间线位置标记失败，需要更新的时间线Id= " + map.get("minValueId").toString();
				}
				mapUpdate.put("owner", "shinion_update_"+ flg);//存入
				String queryIdUpdate = "insertAndTrans.updateOneGpsTimeLineData";
				queryService.update(queryIdUpdate, mapUpdate);
				mylog.info("更新一个时间线成功，更新数据为：" +map.toString());
			}else {
				msg += "无法更新时间线：获取时间线更新参数失败,当前参数：" + map.toString();
			}
			
		} catch (Exception e) {
			// TODO: handle exception
			msg += "更新时间线数据失败：" + e.getMessage() + " , ----------------更新数据：" + map.toString();
		}
		return msg;
	}
	
}
